home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2010 April / PCWorld0410.iso / hity wydania / Ubuntu 9.10 PL / karmelkowy-koliberek-desktop-9.10-i386-PL.iso / casper / filesystem.squashfs / usr / share / system-config-printer / cupspk.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2009-10-28  |  19.5 KB  |  628 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. import os
  5. import sys
  6. import tempfile
  7. import cups
  8. import dbus
  9. import gtk
  10. from debug import debugprint
  11. from dbus.mainloop.glib import DBusGMainLoop
  12. DBusGMainLoop(set_as_default = True)
  13. PK_AUTH_NAME = 'org.freedesktop.PolicyKit.AuthenticationAgent'
  14. PK_AUTH_PATH = '/org/gnome/PolicyKit/Manager'
  15. PK_AUTH_IFACE = 'org.freedesktop.PolicyKit.AuthenticationAgent'
  16. CUPS_PK_NAME = 'org.opensuse.CupsPkHelper.Mechanism'
  17. CUPS_PK_PATH = '/'
  18. CUPS_PK_IFACE = 'org.opensuse.CupsPkHelper.Mechanism'
  19. CUPS_PK_NEED_AUTH = 'org.opensuse.CupsPkHelper.Mechanism.NotPrivileged'
  20. pk_auth_ret = False
  21. pk_auth_error = None
  22. pk_auth_running = False
  23. pk_auth_done = False
  24.  
  25. def _pk_auth_reply_handler(ret):
  26.     global pk_auth_ret, pk_auth_done
  27.     pk_auth_ret = ret
  28.     pk_auth_done = True
  29.  
  30.  
  31. def _pk_auth_error_handler(e):
  32.     global pk_auth_error, pk_auth_done
  33.     pk_auth_error = str(e)
  34.     pk_auth_done = True
  35.  
  36.  
  37. class Connection:
  38.     
  39.     def __init__(self, host, port, encryption):
  40.         self._parent = None
  41.         
  42.         try:
  43.             self._session_bus = dbus.SessionBus()
  44.             self._system_bus = dbus.SystemBus()
  45.         except dbus.exceptions.DBusException:
  46.             self._session_bus = None
  47.             self._system_bus = None
  48.  
  49.         self._connection = cups.Connection(host = host, port = port, encryption = encryption)
  50.         self._hack_subclass()
  51.  
  52.     
  53.     def _hack_subclass(self):
  54.         methodtype = type(self._connection.getPrinters)
  55.         for fname in dir(self._connection):
  56.             if fname[0] == '_':
  57.                 continue
  58.             
  59.             fn = getattr(self._connection, fname)
  60.             if type(fn) != methodtype:
  61.                 continue
  62.             
  63.             if not hasattr(self, fname):
  64.                 setattr(self, fname, fn.__call__)
  65.                 continue
  66.         
  67.  
  68.     
  69.     def set_parent(self, parent):
  70.         self._parent = parent
  71.  
  72.     
  73.     def _get_cups_pk(self):
  74.         
  75.         try:
  76.             object = self._system_bus.get_object(CUPS_PK_NAME, CUPS_PK_PATH)
  77.             return dbus.Interface(object, CUPS_PK_IFACE)
  78.         except dbus.exceptions.DBusException:
  79.             return None
  80.             except AttributeError:
  81.                 return None
  82.             else:
  83.                 return None
  84.  
  85.  
  86.     
  87.     def _obtain_auth(self, action, xid = 0):
  88.         global pk_auth_ret, pk_auth_error, pk_auth_done, pk_auth_running, pk_auth_running
  89.         if pk_auth_running:
  90.             return False
  91.         pk_auth_ret = False
  92.         pk_auth_error = None
  93.         pk_auth_done = False
  94.         pk_auth_object = self._session_bus.get_object(PK_AUTH_NAME, PK_AUTH_PATH)
  95.         pk_auth = dbus.Interface(pk_auth_object, PK_AUTH_IFACE)
  96.         pk_auth_running = True
  97.         pk_auth.ObtainAuthorization(action, dbus.UInt32(xid), dbus.UInt32(os.getpid()), reply_handler = _pk_auth_reply_handler, error_handler = _pk_auth_error_handler, timeout = 0x80000000L / 1000)
  98.         while not pk_auth_done:
  99.             gtk.main_iteration(True)
  100.             continue
  101.             pk_auth_running
  102.         pk_auth_running = False
  103.         if pk_auth_error != None:
  104.             if pk_auth_error.find('org.freedesktop.DBus.Error.NoReply') == 0:
  105.                 return False
  106.             raise dbus.exceptions.DBusException(pk_auth_error)
  107.         pk_auth_error != None
  108.         if not type(pk_auth_ret) == dbus.Boolean:
  109.             return False
  110.         return pk_auth_ret != 0
  111.  
  112.     
  113.     def _handle_exception_with_auth(self, e):
  114.         if e.get_dbus_name() != CUPS_PK_NEED_AUTH:
  115.             return False
  116.         tokens = e.get_dbus_message().split(' ', 2)
  117.         if len(tokens) != 3:
  118.             return False
  119.         
  120.         try:
  121.             xid = 0
  122.             ret = self._obtain_auth(tokens[0], xid)
  123.         except dbus.exceptions.DBusException:
  124.             len(tokens) != 3
  125.             len(tokens) != 3
  126.             e.get_dbus_name() != CUPS_PK_NEED_AUTH
  127.             return False
  128.  
  129.         if not ret:
  130.             raise cups.IPPError(cups.IPP_NOT_AUTHORIZED, 'pkcancel')
  131.         ret
  132.         return True
  133.  
  134.     
  135.     def _call_with_pk_and_fallback(self, use_fallback, pk_function_name, pk_args, fallback_function, *args, **kwds):
  136.         pk_function = None
  137.         if not use_fallback:
  138.             cups_pk = self._get_cups_pk()
  139.             if cups_pk:
  140.                 
  141.                 try:
  142.                     pk_function = cups_pk.get_dbus_method(pk_function_name)
  143.                 except dbus.exceptions.DBusException:
  144.                     pass
  145.                 except:
  146.                     None<EXCEPTION MATCH>dbus.exceptions.DBusException
  147.                 
  148.  
  149.             None<EXCEPTION MATCH>dbus.exceptions.DBusException
  150.         
  151.         if use_fallback or not pk_function:
  152.             return fallback_function(*args, **kwds)
  153.         pk_retval = 'PolicyKit communication issue'
  154.         while True:
  155.             
  156.             try:
  157.                 pk_retval = pk_function(*pk_args)
  158.                 if type(pk_retval) == tuple:
  159.                     retval = pk_retval[1:]
  160.                     if pk_retval[0] == '':
  161.                         if len(retval) == 1:
  162.                             return retval[0]
  163.                         return retval
  164.                     pk_retval[0] == ''
  165.                 
  166.             continue
  167.             except dbus.exceptions.DBusException:
  168.                 not pk_function
  169.                 e = not pk_function
  170.                 if not self._handle_exception_with_auth(e):
  171.                     break
  172.                 
  173.                 self._handle_exception_with_auth(e)
  174.             
  175.  
  176.             not pk_function<EXCEPTION MATCH>dbus.exceptions.DBusException
  177.         if pk_retval != '':
  178.             debugprint('PolicyKit call to %s did not work: %s' % (pk_function_name, pk_retval))
  179.             return fallback_function(*args, **kwds)
  180.  
  181.     
  182.     def _args_to_tuple(self, types, *args):
  183.         retval = [
  184.             False]
  185.         if len(types) != len(args):
  186.             retval[0] = True
  187.             retval.extend(types)
  188.             return tuple(types)
  189.         exception = False
  190.         for i in range(len(types)):
  191.             if type(args[i]) != types[i]:
  192.                 if types[i] == str and type(args[i]) == unicode:
  193.                     pass
  194.                 elif types[i] == str and type(args[i]) == int:
  195.                     retval.append(str(args[i]))
  196.                     continue
  197.                 elif types[i] == str and type(args[i]) == float:
  198.                     retval.append(str(args[i]))
  199.                     continue
  200.                 elif types[i] == str and type(args[i]) == bool:
  201.                     retval.append(str(args[i]))
  202.                     continue
  203.                 elif types[i] == str and args[i] == None:
  204.                     retval.append('')
  205.                     continue
  206.                 elif types[i] == list and type(args[i]) == tuple:
  207.                     retval.append(list(args[i]))
  208.                     continue
  209.                 elif types[i] == list and args[i] == None:
  210.                     retval.append([])
  211.                     continue
  212.                 else:
  213.                     exception = True
  214.             
  215.             retval.append(args[i])
  216.         
  217.         retval[0] = exception
  218.         return tuple(retval)
  219.  
  220.     
  221.     def _kwds_to_vars(self, names, **kwds):
  222.         ret = []
  223.         for name in names:
  224.             if kwds.has_key(name):
  225.                 ret.append(kwds[name])
  226.                 continue
  227.             ret.append('')
  228.         
  229.         return tuple(ret)
  230.  
  231.     
  232.     def getDevices(self, *args, **kwds):
  233.         use_pycups = False
  234.         timeout = 0
  235.         include_schemes = ''
  236.         exclude_schemes = ''
  237.         if len(args) == 3:
  238.             (use_pycups, timeout, include_schemes, exclude_schemes) = self._args_to_tuple([
  239.                 int,
  240.                 str,
  241.                 str], *args)
  242.         elif kwds.has_key('timeout'):
  243.             timeout = kwds['timeout']
  244.         
  245.         if kwds.has_key('include_schemes'):
  246.             include_schemes = kwds['include_schemes']
  247.         
  248.         if kwds.has_key('exclude_schemes'):
  249.             exclude_schemes = kwds['exclude_schemes']
  250.         
  251.         pk_args = (timeout, include_schemes, exclude_schemes)
  252.         result = self._call_with_pk_and_fallback(use_pycups, 'DevicesGet', pk_args, self._connection.getDevices, *args, **kwds)
  253.         if len(result.keys()) > 0 and type(result[result.keys()[0]]) == dict:
  254.             return result
  255.         result_str = { }
  256.         if result != None:
  257.             for i in result.keys():
  258.                 if type(i) == dbus.String:
  259.                     result_str[str(i)] = str(result[i])
  260.                     continue
  261.                 type(result[result.keys()[0]]) == dict
  262.                 result_str[i] = result[i]
  263.             
  264.         
  265.         devices = { }
  266.         n = 0
  267.         postfix = ':' + str(n)
  268.         device_keys = _[1]
  269.         for x in result_str.keys():
  270.             if x.endswith(postfix):
  271.                 continue
  272.             _[2][x]
  273.             device_keys = _[2]
  274.             []
  275.         return devices
  276.  
  277.     
  278.     def cancelJob(self, *args, **kwds):
  279.         (use_pycups, jobid) = self._args_to_tuple([
  280.             int], *args)
  281.         pk_args = (jobid,)
  282.         self._call_with_pk_and_fallback(use_pycups, 'JobCancel', pk_args, self._connection.cancelJob, *args, **kwds)
  283.  
  284.     
  285.     def setJobHoldUntil(self, *args, **kwds):
  286.         (use_pycups, jobid, job_hold_until) = self._args_to_tuple([
  287.             int,
  288.             str], *args)
  289.         pk_args = (jobid, job_hold_until)
  290.         self._call_with_pk_and_fallback(use_pycups, 'JobSetHoldUntil', pk_args, self._connection.setJobHoldUntil, *args, **kwds)
  291.  
  292.     
  293.     def restartJob(self, *args, **kwds):
  294.         (use_pycups, jobid) = self._args_to_tuple([
  295.             int], *args)
  296.         pk_args = (jobid,)
  297.         self._call_with_pk_and_fallback(use_pycups, 'JobRestart', pk_args, self._connection.restartJob, *args, **kwds)
  298.  
  299.     
  300.     def getFile(self, *args, **kwds):
  301.         """ Keeping this as an alternative for the code.
  302.             We don't use it because it's not possible to know if the call was a
  303.             PK-one (and so we push the content of a temporary filename to fd or
  304.             file) or a non-PK-one (in which case nothing should be done).
  305.  
  306.                 filename = None
  307.                 fd = None
  308.                 file = None
  309.                 if use_pycups:
  310.                     if len(kwds) != 1:
  311.                         use_pycups = True
  312.                     elif kwds.has_key('filename'):
  313.                         filename = kwds['filename']
  314.                     elif kwds.has_key('fd'):
  315.                         fd = kwds['fd']
  316.                     elif kwds.has_key('file'):
  317.                         file = kwds['file']
  318.                     else:
  319.                         use_pycups = True
  320.  
  321.                     if fd or file:
  322.         """
  323.         file_object = None
  324.         fd = None
  325.         if len(args) == 2:
  326.             (use_pycups, resource, filename) = self._args_to_tuple([
  327.                 str,
  328.                 str], *args)
  329.         else:
  330.             (use_pycups, resource) = self._args_to_tuple([
  331.                 str], *args)
  332.             if kwds.has_key('filename'):
  333.                 filename = kwds['filename']
  334.             elif kwds.has_key('fd'):
  335.                 fd = kwds['fd']
  336.             elif kwds.has_key('file'):
  337.                 file_object = kwds['file']
  338.             elif not use_pycups:
  339.                 raise TypeError()
  340.             else:
  341.                 filename = None
  342.         if not use_pycups:
  343.             if fd != None or file_object != None:
  344.                 (tmpfd, tmpfname) = tempfile.mkstemp()
  345.                 os.close(tmpfd)
  346.                 pk_args = (resource, tmpfname)
  347.                 self._call_with_pk_and_fallback(use_pycups, 'FileGet', pk_args, self._connection.getFile, *args, **kwds)
  348.                 tmpfd = os.open(tmpfname, os.O_RDONLY)
  349.                 tmpfile = os.fdopen(tmpfd, 'r')
  350.                 tmpfile.seek(0)
  351.                 if fd != None:
  352.                     os.lseek(fd, 0, os.SEEK_SET)
  353.                     line = tmpfile.readline()
  354.                     while line != '':
  355.                         os.write(fd, line)
  356.                         line = tmpfile.readline()
  357.                 else:
  358.                     file_object.seek(0)
  359.                     line = tmpfile.readline()
  360.                     while line != '':
  361.                         file_object.write(line)
  362.                         line = tmpfile.readline()
  363.                 tmpfile.close()
  364.                 os.remove(tmpfname)
  365.             else:
  366.                 pk_args = (resource, filename)
  367.                 self._call_with_pk_and_fallback(use_pycups, 'FileGet', pk_args, self._connection.getFile, *args, **kwds)
  368.  
  369.     
  370.     def putFile(self, *args, **kwds):
  371.         if len(args) == 2:
  372.             (use_pycups, resource, filename) = self._args_to_tuple([
  373.                 str,
  374.                 str], *args)
  375.         else:
  376.             (use_pycups, resource) = self._args_to_tuple([
  377.                 str], *args)
  378.             if kwds.has_key('filename'):
  379.                 filename = kwds['filename']
  380.             elif kwds.has_key('fd'):
  381.                 fd = kwds['fd']
  382.             elif kwds.has_key('file'):
  383.                 file_object = kwds['file']
  384.             elif not use_pycups:
  385.                 raise TypeError()
  386.             else:
  387.                 filename = None
  388.         if not use_pycups:
  389.             if fd != None or file_object != None:
  390.                 (tmpfd, tmpfname) = tempfile.mkstemp()
  391.                 os.lseek(tmpfd, 0, os.SEEK_SET)
  392.                 if fd != None:
  393.                     os.lseek(fd, 0, os.SEEK_SET)
  394.                     buf = os.read(fd, 512)
  395.                     while buf != '':
  396.                         os.write(tmpfd, buf)
  397.                         buf = os.read(fd, 512)
  398.                 else:
  399.                     file_object.seek(0)
  400.                     line = file_object.readline()
  401.                     while line != '':
  402.                         os.write(tmpfd, line)
  403.                         line = file_object.readline()
  404.                 os.close(tmpfd)
  405.                 pk_args = (resource, tmpfname)
  406.                 self._call_with_pk_and_fallback(use_pycups, 'FilePut', pk_args, self._connection.putFile, *args, **kwds)
  407.                 os.remove(tmpfname)
  408.             else:
  409.                 pk_args = (resource, filename)
  410.                 self._call_with_pk_and_fallback(use_pycups, 'FilePut', pk_args, self._connection.putFile, *args, **kwds)
  411.  
  412.     
  413.     def addPrinter(self, *args, **kwds):
  414.         (use_pycups, name) = self._args_to_tuple([
  415.             str], *args)
  416.         (filename, ppdname, info, location, device, ppd) = self._kwds_to_vars([
  417.             'filename',
  418.             'ppdname',
  419.             'info',
  420.             'location',
  421.             'device',
  422.             'ppd'], **kwds)
  423.         need_unlink = False
  424.         if not ppdname and not filename and ppd:
  425.             (fd, filename) = tempfile.mkstemp()
  426.             ppd.writeFd(fd)
  427.             os.close(fd)
  428.             need_unlink = True
  429.         
  430.         if filename and not ppdname:
  431.             pk_args = (name, device, filename, info, location)
  432.             self._call_with_pk_and_fallback(use_pycups, 'PrinterAddWithPpdFile', pk_args, self._connection.addPrinter, *args, **kwds)
  433.             if need_unlink:
  434.                 os.unlink(filename)
  435.             
  436.         else:
  437.             pk_args = (name, device, ppdname, info, location)
  438.             self._call_with_pk_and_fallback(use_pycups, 'PrinterAdd', pk_args, self._connection.addPrinter, *args, **kwds)
  439.  
  440.     
  441.     def setPrinterDevice(self, *args, **kwds):
  442.         (use_pycups, name, device) = self._args_to_tuple([
  443.             str,
  444.             str], *args)
  445.         pk_args = (name, device)
  446.         self._call_with_pk_and_fallback(use_pycups, 'PrinterSetDevice', pk_args, self._connection.setPrinterDevice, *args, **kwds)
  447.  
  448.     
  449.     def setPrinterInfo(self, *args, **kwds):
  450.         (use_pycups, name, info) = self._args_to_tuple([
  451.             str,
  452.             str], *args)
  453.         pk_args = (name, info)
  454.         self._call_with_pk_and_fallback(use_pycups, 'PrinterSetInfo', pk_args, self._connection.setPrinterInfo, *args, **kwds)
  455.  
  456.     
  457.     def setPrinterLocation(self, *args, **kwds):
  458.         (use_pycups, name, location) = self._args_to_tuple([
  459.             str,
  460.             str], *args)
  461.         pk_args = (name, location)
  462.         self._call_with_pk_and_fallback(use_pycups, 'PrinterSetLocation', pk_args, self._connection.setPrinterLocation, *args, **kwds)
  463.  
  464.     
  465.     def setPrinterShared(self, *args, **kwds):
  466.         (use_pycups, name, shared) = self._args_to_tuple([
  467.             str,
  468.             bool], *args)
  469.         pk_args = (name, shared)
  470.         self._call_with_pk_and_fallback(use_pycups, 'PrinterSetShared', pk_args, self._connection.setPrinterShared, *args, **kwds)
  471.  
  472.     
  473.     def setPrinterJobSheets(self, *args, **kwds):
  474.         (use_pycups, name, start, end) = self._args_to_tuple([
  475.             str,
  476.             str,
  477.             str], *args)
  478.         pk_args = (name, start, end)
  479.         self._call_with_pk_and_fallback(use_pycups, 'PrinterSetJobSheets', pk_args, self._connection.setPrinterJobSheets, *args, **kwds)
  480.  
  481.     
  482.     def setPrinterErrorPolicy(self, *args, **kwds):
  483.         (use_pycups, name, policy) = self._args_to_tuple([
  484.             str,
  485.             str], *args)
  486.         pk_args = (name, policy)
  487.         self._call_with_pk_and_fallback(use_pycups, 'PrinterSetErrorPolicy', pk_args, self._connection.setPrinterErrorPolicy, *args, **kwds)
  488.  
  489.     
  490.     def setPrinterOpPolicy(self, *args, **kwds):
  491.         (use_pycups, name, policy) = self._args_to_tuple([
  492.             str,
  493.             str], *args)
  494.         pk_args = (name, policy)
  495.         self._call_with_pk_and_fallback(use_pycups, 'PrinterSetOpPolicy', pk_args, self._connection.setPrinterOpPolicy, *args, **kwds)
  496.  
  497.     
  498.     def setPrinterUsersAllowed(self, *args, **kwds):
  499.         (use_pycups, name, users) = self._args_to_tuple([
  500.             str,
  501.             list], *args)
  502.         pk_args = (name, users)
  503.         self._call_with_pk_and_fallback(use_pycups, 'PrinterSetUsersAllowed', pk_args, self._connection.setPrinterUsersAllowed, *args, **kwds)
  504.  
  505.     
  506.     def setPrinterUsersDenied(self, *args, **kwds):
  507.         (use_pycups, name, users) = self._args_to_tuple([
  508.             str,
  509.             list], *args)
  510.         pk_args = (name, users)
  511.         self._call_with_pk_and_fallback(use_pycups, 'PrinterSetUsersDenied', pk_args, self._connection.setPrinterUsersDenied, *args, **kwds)
  512.  
  513.     
  514.     def addPrinterOptionDefault(self, *args, **kwds):
  515.         (use_pycups, name, option, value) = self._args_to_tuple([
  516.             str,
  517.             str,
  518.             str], *args)
  519.         if not use_pycups:
  520.             values = (value,)
  521.         else:
  522.             (use_pycups, name, option, values) = self._args_to_tuple([
  523.                 str,
  524.                 str,
  525.                 list], *args)
  526.         pk_args = (name, option, values)
  527.         self._call_with_pk_and_fallback(use_pycups, 'PrinterAddOptionDefault', pk_args, self._connection.addPrinterOptionDefault, *args, **kwds)
  528.  
  529.     
  530.     def deletePrinterOptionDefault(self, *args, **kwds):
  531.         (use_pycups, name, option) = self._args_to_tuple([
  532.             str,
  533.             str], *args)
  534.         pk_args = (name, option)
  535.         self._call_with_pk_and_fallback(use_pycups, 'PrinterDeleteOptionDefault', pk_args, self._connection.deletePrinterOptionDefault, *args, **kwds)
  536.  
  537.     
  538.     def deletePrinter(self, *args, **kwds):
  539.         (use_pycups, name) = self._args_to_tuple([
  540.             str], *args)
  541.         pk_args = (name,)
  542.         self._call_with_pk_and_fallback(use_pycups, 'PrinterDelete', pk_args, self._connection.deletePrinter, *args, **kwds)
  543.  
  544.     
  545.     def addPrinterToClass(self, *args, **kwds):
  546.         (use_pycups, printer, name) = self._args_to_tuple([
  547.             str,
  548.             str], *args)
  549.         pk_args = (name, printer)
  550.         self._call_with_pk_and_fallback(use_pycups, 'ClassAddPrinter', pk_args, self._connection.addPrinterToClass, *args, **kwds)
  551.  
  552.     
  553.     def deletePrinterFromClass(self, *args, **kwds):
  554.         (use_pycups, printer, name) = self._args_to_tuple([
  555.             str,
  556.             str], *args)
  557.         pk_args = (name, printer)
  558.         self._call_with_pk_and_fallback(use_pycups, 'ClassDeletePrinter', pk_args, self._connection.deletePrinterFromClass, *args, **kwds)
  559.  
  560.     
  561.     def deleteClass(self, *args, **kwds):
  562.         (use_pycups, name) = self._args_to_tuple([
  563.             str], *args)
  564.         pk_args = (name,)
  565.         self._call_with_pk_and_fallback(use_pycups, 'ClassDelete', pk_args, self._connection.deleteClass, *args, **kwds)
  566.  
  567.     
  568.     def setDefault(self, *args, **kwds):
  569.         (use_pycups, name) = self._args_to_tuple([
  570.             str], *args)
  571.         pk_args = (name,)
  572.         self._call_with_pk_and_fallback(use_pycups, 'PrinterSetDefault', pk_args, self._connection.setDefault, *args, **kwds)
  573.  
  574.     
  575.     def enablePrinter(self, *args, **kwds):
  576.         (use_pycups, name) = self._args_to_tuple([
  577.             str], *args)
  578.         pk_args = (name, True)
  579.         self._call_with_pk_and_fallback(use_pycups, 'PrinterSetEnabled', pk_args, self._connection.enablePrinter, *args, **kwds)
  580.  
  581.     
  582.     def disablePrinter(self, *args, **kwds):
  583.         (use_pycups, name) = self._args_to_tuple([
  584.             str], *args)
  585.         pk_args = (name, False)
  586.         self._call_with_pk_and_fallback(use_pycups, 'PrinterSetEnabled', pk_args, self._connection.disablePrinter, *args, **kwds)
  587.  
  588.     
  589.     def acceptJobs(self, *args, **kwds):
  590.         (use_pycups, name) = self._args_to_tuple([
  591.             str], *args)
  592.         pk_args = (name, True, '')
  593.         self._call_with_pk_and_fallback(use_pycups, 'PrinterSetAcceptJobs', pk_args, self._connection.acceptJobs, *args, **kwds)
  594.  
  595.     
  596.     def rejectJobs(self, *args, **kwds):
  597.         (use_pycups, name) = self._args_to_tuple([
  598.             str], *args)
  599.         (reason,) = self._kwds_to_vars([
  600.             'reason'], **kwds)
  601.         pk_args = (name, False, reason)
  602.         self._call_with_pk_and_fallback(use_pycups, 'PrinterSetAcceptJobs', pk_args, self._connection.rejectJobs, *args, **kwds)
  603.  
  604.     
  605.     def adminGetServerSettings(self, *args, **kwds):
  606.         use_pycups = False
  607.         pk_args = ()
  608.         result = self._call_with_pk_and_fallback(use_pycups, 'ServerGetSettings', pk_args, self._connection.adminGetServerSettings, *args, **kwds)
  609.         settings = { }
  610.         if result != None:
  611.             for i in result.keys():
  612.                 if type(i) == dbus.String:
  613.                     settings[str(i)] = str(result[i])
  614.                     continue
  615.                 settings[i] = result[i]
  616.             
  617.         
  618.         return settings
  619.  
  620.     
  621.     def adminSetServerSettings(self, *args, **kwds):
  622.         (use_pycups, settings) = self._args_to_tuple([
  623.             dict], *args)
  624.         pk_args = (settings,)
  625.         self._call_with_pk_and_fallback(use_pycups, 'ServerSetSettings', pk_args, self._connection.adminSetServerSettings, *args, **kwds)
  626.  
  627.  
  628.